// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2016
// Mehdi Goli    Codeplay Software Ltd.
// Ralph Potter  Codeplay Software Ltd.
// Luke Iwanski  Codeplay Software Ltd.
// Contact: <eigen@codeplay.com>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

#define EIGEN_TEST_NO_LONGDOUBLE
#define EIGEN_TEST_NO_COMPLEX

#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
#define EIGEN_USE_SYCL

#include "main.h"
#include <unsupported/Eigen/CXX11/Tensor>

using Eigen::Tensor;
static const int DataLayout = ColMajor;

template<typename DataType, typename IndexType>
static void
test_simple_image_patch_sycl(const Eigen::SyclDevice& sycl_device)
{
	IndexType sizeDim1 = 2;
	IndexType sizeDim2 = 3;
	IndexType sizeDim3 = 5;
	IndexType sizeDim4 = 7;
	array<IndexType, 4> tensorColMajorRange = { { sizeDim1, sizeDim2, sizeDim3, sizeDim4 } };
	array<IndexType, 4> tensorRowMajorRange = { { sizeDim4, sizeDim3, sizeDim2, sizeDim1 } };
	Tensor<DataType, 4, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
	Tensor<DataType, 4, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);
	tensor_col_major.setRandom();

	DataType* gpu_data_col_major =
		static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
	DataType* gpu_data_row_major =
		static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
	TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
	TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);

	sycl_device.memcpyHostToDevice(
		gpu_data_col_major, tensor_col_major.data(), (tensor_col_major.size()) * sizeof(DataType));
	gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
	sycl_device.memcpyDeviceToHost(
		tensor_row_major.data(), gpu_data_row_major, (tensor_col_major.size()) * sizeof(DataType));

	VERIFY_IS_EQUAL(tensor_col_major.dimension(0), tensor_row_major.dimension(3));
	VERIFY_IS_EQUAL(tensor_col_major.dimension(1), tensor_row_major.dimension(2));
	VERIFY_IS_EQUAL(tensor_col_major.dimension(2), tensor_row_major.dimension(1));
	VERIFY_IS_EQUAL(tensor_col_major.dimension(3), tensor_row_major.dimension(0));

	// Single pixel patch: ColMajor
	array<IndexType, 5> patchColMajorTensorRange = { { sizeDim1, 1, 1, sizeDim2 * sizeDim3, sizeDim4 } };
	Tensor<DataType, 5, DataLayout, IndexType> single_patch_col_major(patchColMajorTensorRange);
	size_t patchTensorBuffSize = single_patch_col_major.size() * sizeof(DataType);
	DataType* gpu_data_single_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_single_patch_col_major(gpu_data_single_patch_col_major,
																					 patchColMajorTensorRange);
	gpu_single_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(1, 1);
	sycl_device.memcpyDeviceToHost(single_patch_col_major.data(), gpu_data_single_patch_col_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(single_patch_col_major.dimension(0), 2);
	VERIFY_IS_EQUAL(single_patch_col_major.dimension(1), 1);
	VERIFY_IS_EQUAL(single_patch_col_major.dimension(2), 1);
	VERIFY_IS_EQUAL(single_patch_col_major.dimension(3), 3 * 5);
	VERIFY_IS_EQUAL(single_patch_col_major.dimension(4), 7);

	// Single pixel patch: RowMajor
	array<IndexType, 5> patchRowMajorTensorRange = { { sizeDim4, sizeDim2 * sizeDim3, 1, 1, sizeDim1 } };
	Tensor<DataType, 5, RowMajor, IndexType> single_patch_row_major(patchRowMajorTensorRange);
	patchTensorBuffSize = single_patch_row_major.size() * sizeof(DataType);
	DataType* gpu_data_single_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_single_patch_row_major(gpu_data_single_patch_row_major,
																				   patchRowMajorTensorRange);
	gpu_single_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(1, 1);
	sycl_device.memcpyDeviceToHost(single_patch_row_major.data(), gpu_data_single_patch_row_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(single_patch_row_major.dimension(0), 7);
	VERIFY_IS_EQUAL(single_patch_row_major.dimension(1), 3 * 5);
	VERIFY_IS_EQUAL(single_patch_row_major.dimension(2), 1);
	VERIFY_IS_EQUAL(single_patch_row_major.dimension(3), 1);
	VERIFY_IS_EQUAL(single_patch_row_major.dimension(4), 2);

	for (IndexType i = 0; i < tensor_col_major.size(); ++i) {
		// ColMajor
		if (tensor_col_major.data()[i] != single_patch_col_major.data()[i]) {
			std::cout << "Mismatch detected at index colmajor " << i << " : " << tensor_col_major.data()[i] << " vs "
					  << single_patch_col_major.data()[i] << std::endl;
		}
		VERIFY_IS_EQUAL(single_patch_col_major.data()[i], tensor_col_major.data()[i]);
		// RowMajor
		if (tensor_row_major.data()[i] != single_patch_row_major.data()[i]) {
			std::cout << "Mismatch detected at index row major" << i << " : " << tensor_row_major.data()[i] << " vs "
					  << single_patch_row_major.data()[i] << std::endl;
		}
		VERIFY_IS_EQUAL(single_patch_row_major.data()[i], tensor_row_major.data()[i]);
		VERIFY_IS_EQUAL(tensor_col_major.data()[i], tensor_row_major.data()[i]);
		VERIFY_IS_EQUAL(single_patch_col_major.data()[i], single_patch_row_major.data()[i]);
	}

	// Entire image patch: ColMajor
	patchColMajorTensorRange = { { sizeDim1, sizeDim2, sizeDim3, sizeDim2 * sizeDim3, sizeDim4 } };
	Tensor<DataType, 5, DataLayout, IndexType> entire_image_patch_col_major(patchColMajorTensorRange);
	patchTensorBuffSize = entire_image_patch_col_major.size() * sizeof(DataType);
	DataType* gpu_data_entire_image_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_entire_image_patch_col_major(
		gpu_data_entire_image_patch_col_major, patchColMajorTensorRange);
	gpu_entire_image_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(3, 5);
	sycl_device.memcpyDeviceToHost(
		entire_image_patch_col_major.data(), gpu_data_entire_image_patch_col_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(0), 2);
	VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(1), 3);
	VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(2), 5);
	VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(3), 3 * 5);
	VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(4), 7);

	// Entire image patch: RowMajor
	patchRowMajorTensorRange = { { sizeDim4, sizeDim2 * sizeDim3, sizeDim3, sizeDim2, sizeDim1 } };
	Tensor<DataType, 5, RowMajor, IndexType> entire_image_patch_row_major(patchRowMajorTensorRange);
	patchTensorBuffSize = entire_image_patch_row_major.size() * sizeof(DataType);
	DataType* gpu_data_entire_image_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_entire_image_patch_row_major(
		gpu_data_entire_image_patch_row_major, patchRowMajorTensorRange);
	gpu_entire_image_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(3, 5);
	sycl_device.memcpyDeviceToHost(
		entire_image_patch_row_major.data(), gpu_data_entire_image_patch_row_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(0), 7);
	VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(1), 3 * 5);
	VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(2), 5);
	VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(3), 3);
	VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(4), 2);

	for (IndexType i = 0; i < 3; ++i) {
		for (IndexType j = 0; j < 5; ++j) {
			IndexType patchId = i + 3 * j;
			for (IndexType r = 0; r < 3; ++r) {
				for (IndexType c = 0; c < 5; ++c) {
					for (IndexType d = 0; d < 2; ++d) {
						for (IndexType b = 0; b < 7; ++b) {
							DataType expected_col_major = 0.0f;
							DataType expected_row_major = 0.0f;
							if (r - 1 + i >= 0 && c - 2 + j >= 0 && r - 1 + i < 3 && c - 2 + j < 5) {
								expected_col_major = tensor_col_major(d, r - 1 + i, c - 2 + j, b);
								expected_row_major = tensor_row_major(b, c - 2 + j, r - 1 + i, d);
							}
							// ColMajor
							if (entire_image_patch_col_major(d, r, c, patchId, b) != expected_col_major) {
								std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r
										  << " c=" << c << " d=" << d << " b=" << b << std::endl;
							}
							VERIFY_IS_EQUAL(entire_image_patch_col_major(d, r, c, patchId, b), expected_col_major);
							// RowMajor
							if (entire_image_patch_row_major(b, patchId, c, r, d) != expected_row_major) {
								std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r
										  << " c=" << c << " d=" << d << " b=" << b << std::endl;
							}
							VERIFY_IS_EQUAL(entire_image_patch_row_major(b, patchId, c, r, d), expected_row_major);
							// Check that ColMajor and RowMajor agree.
							VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
						}
					}
				}
			}
		}
	}

	// 2D patch: ColMajor
	patchColMajorTensorRange = { { sizeDim1, 2, 2, sizeDim2 * sizeDim3, sizeDim4 } };
	Tensor<DataType, 5, DataLayout, IndexType> twod_patch_col_major(patchColMajorTensorRange);
	patchTensorBuffSize = twod_patch_col_major.size() * sizeof(DataType);
	DataType* gpu_data_twod_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_twod_patch_col_major(gpu_data_twod_patch_col_major,
																				   patchColMajorTensorRange);
	gpu_twod_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(2, 2);
	sycl_device.memcpyDeviceToHost(twod_patch_col_major.data(), gpu_data_twod_patch_col_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(twod_patch_col_major.dimension(0), 2);
	VERIFY_IS_EQUAL(twod_patch_col_major.dimension(1), 2);
	VERIFY_IS_EQUAL(twod_patch_col_major.dimension(2), 2);
	VERIFY_IS_EQUAL(twod_patch_col_major.dimension(3), 3 * 5);
	VERIFY_IS_EQUAL(twod_patch_col_major.dimension(4), 7);

	// 2D patch: RowMajor
	patchRowMajorTensorRange = { { sizeDim4, sizeDim2 * sizeDim3, 2, 2, sizeDim1 } };
	Tensor<DataType, 5, RowMajor, IndexType> twod_patch_row_major(patchRowMajorTensorRange);
	patchTensorBuffSize = twod_patch_row_major.size() * sizeof(DataType);
	DataType* gpu_data_twod_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_twod_patch_row_major(gpu_data_twod_patch_row_major,
																				 patchRowMajorTensorRange);
	gpu_twod_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(2, 2);
	sycl_device.memcpyDeviceToHost(twod_patch_row_major.data(), gpu_data_twod_patch_row_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(twod_patch_row_major.dimension(0), 7);
	VERIFY_IS_EQUAL(twod_patch_row_major.dimension(1), 3 * 5);
	VERIFY_IS_EQUAL(twod_patch_row_major.dimension(2), 2);
	VERIFY_IS_EQUAL(twod_patch_row_major.dimension(3), 2);
	VERIFY_IS_EQUAL(twod_patch_row_major.dimension(4), 2);

	// Based on the calculation described in TensorTraits.h, padding happens to be 0.
	IndexType row_padding = 0;
	IndexType col_padding = 0;
	IndexType stride = 1;

	for (IndexType i = 0; i < 3; ++i) {
		for (IndexType j = 0; j < 5; ++j) {
			IndexType patchId = i + 3 * j;
			for (IndexType r = 0; r < 2; ++r) {
				for (IndexType c = 0; c < 2; ++c) {
					for (IndexType d = 0; d < 2; ++d) {
						for (IndexType b = 0; b < 7; ++b) {
							DataType expected_col_major = 0.0f;
							DataType expected_row_major = 0.0f;
							IndexType row_offset = r * stride + i - row_padding;
							IndexType col_offset = c * stride + j - col_padding;
							// ColMajor
							if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor_col_major.dimension(1) &&
								col_offset < tensor_col_major.dimension(2)) {
								expected_col_major = tensor_col_major(d, row_offset, col_offset, b);
							}
							if (twod_patch_col_major(d, r, c, patchId, b) != expected_col_major) {
								std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r
										  << " c=" << c << " d=" << d << " b=" << b << std::endl;
							}
							VERIFY_IS_EQUAL(twod_patch_col_major(d, r, c, patchId, b), expected_col_major);

							// RowMajor
							if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor_row_major.dimension(2) &&
								col_offset < tensor_row_major.dimension(1)) {
								expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
							}
							if (twod_patch_row_major(b, patchId, c, r, d) != expected_row_major) {
								std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r
										  << " c=" << c << " d=" << d << " b=" << b << std::endl;
							}
							VERIFY_IS_EQUAL(twod_patch_row_major(b, patchId, c, r, d), expected_row_major);
							// Check that ColMajor and RowMajor agree.
							VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
						}
					}
				}
			}
		}
	}

	sycl_device.deallocate(gpu_data_col_major);
	sycl_device.deallocate(gpu_data_row_major);
	sycl_device.deallocate(gpu_data_single_patch_col_major);
	sycl_device.deallocate(gpu_data_single_patch_row_major);
	sycl_device.deallocate(gpu_data_entire_image_patch_col_major);
	sycl_device.deallocate(gpu_data_entire_image_patch_row_major);
	sycl_device.deallocate(gpu_data_twod_patch_col_major);
	sycl_device.deallocate(gpu_data_twod_patch_row_major);
}

// Verifies VALID padding (no padding) with incrementing values.
template<typename DataType, typename IndexType>
static void
test_patch_padding_valid_sycl(const Eigen::SyclDevice& sycl_device)
{
	IndexType input_depth = 3;
	IndexType input_rows = 3;
	IndexType input_cols = 3;
	IndexType input_batches = 1;
	IndexType ksize = 2;  // Corresponds to the Rows and Cols for tensor.extract_image_patches<>.
	IndexType stride = 2; // Only same stride is supported.

	array<IndexType, 4> tensorColMajorRange = { { input_depth, input_rows, input_cols, input_batches } };
	array<IndexType, 4> tensorRowMajorRange = { { input_batches, input_cols, input_rows, input_depth } };
	Tensor<DataType, 4, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
	Tensor<DataType, 4, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);

	DataType* gpu_data_col_major =
		static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
	DataType* gpu_data_row_major =
		static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
	TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
	TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);

	sycl_device.memcpyHostToDevice(
		gpu_data_col_major, tensor_col_major.data(), (tensor_col_major.size()) * sizeof(DataType));
	gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
	sycl_device.memcpyDeviceToHost(
		tensor_row_major.data(), gpu_data_row_major, (tensor_col_major.size()) * sizeof(DataType));

	VERIFY_IS_EQUAL(tensor_col_major.dimension(0), tensor_row_major.dimension(3));
	VERIFY_IS_EQUAL(tensor_col_major.dimension(1), tensor_row_major.dimension(2));
	VERIFY_IS_EQUAL(tensor_col_major.dimension(2), tensor_row_major.dimension(1));
	VERIFY_IS_EQUAL(tensor_col_major.dimension(3), tensor_row_major.dimension(0));

	// Initializes tensor with incrementing numbers.
	for (IndexType i = 0; i < tensor_col_major.size(); ++i) {
		tensor_col_major.data()[i] = i + 1;
	}
	// ColMajor
	array<IndexType, 5> patchColMajorTensorRange = { { input_depth, ksize, ksize, 1, input_batches } };
	Tensor<DataType, 5, DataLayout, IndexType> result_col_major(patchColMajorTensorRange);
	size_t patchTensorBuffSize = result_col_major.size() * sizeof(DataType);
	DataType* gpu_data_result_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_result_col_major(gpu_data_result_col_major,
																			   patchColMajorTensorRange);
	gpu_result_col_major.device(sycl_device) =
		gpu_col_major.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
	sycl_device.memcpyDeviceToHost(result_col_major.data(), gpu_data_result_col_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(result_col_major.dimension(0), input_depth);   // depth
	VERIFY_IS_EQUAL(result_col_major.dimension(1), ksize);		   // kernel rows
	VERIFY_IS_EQUAL(result_col_major.dimension(2), ksize);		   // kernel cols
	VERIFY_IS_EQUAL(result_col_major.dimension(3), 1);			   // number of patches
	VERIFY_IS_EQUAL(result_col_major.dimension(4), input_batches); // number of batches

	// RowMajor
	array<IndexType, 5> patchRowMajorTensorRange = { { input_batches, 1, ksize, ksize, input_depth } };
	Tensor<DataType, 5, RowMajor, IndexType> result_row_major(patchRowMajorTensorRange);
	patchTensorBuffSize = result_row_major.size() * sizeof(DataType);
	DataType* gpu_data_result_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_result_row_major(gpu_data_result_row_major,
																			 patchRowMajorTensorRange);
	gpu_result_row_major.device(sycl_device) =
		gpu_row_major.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
	sycl_device.memcpyDeviceToHost(result_row_major.data(), gpu_data_result_row_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(result_col_major.dimension(0), result_row_major.dimension(4));
	VERIFY_IS_EQUAL(result_col_major.dimension(1), result_row_major.dimension(3));
	VERIFY_IS_EQUAL(result_col_major.dimension(2), result_row_major.dimension(2));
	VERIFY_IS_EQUAL(result_col_major.dimension(3), result_row_major.dimension(1));
	VERIFY_IS_EQUAL(result_col_major.dimension(4), result_row_major.dimension(0));

	// No padding is carried out.
	IndexType row_padding = 0;
	IndexType col_padding = 0;

	for (IndexType i = 0; (i + stride + ksize - 1) < input_rows; i += stride) {		// input rows
		for (IndexType j = 0; (j + stride + ksize - 1) < input_cols; j += stride) { // input cols
			IndexType patchId = i + input_rows * j;
			for (IndexType r = 0; r < ksize; ++r) {						// patch rows
				for (IndexType c = 0; c < ksize; ++c) {					// patch cols
					for (IndexType d = 0; d < input_depth; ++d) {		// depth
						for (IndexType b = 0; b < input_batches; ++b) { // batch
							DataType expected_col_major = 0.0f;
							DataType expected_row_major = 0.0f;
							IndexType row_offset = r + i - row_padding;
							IndexType col_offset = c + j - col_padding;
							if (row_offset >= 0 && col_offset >= 0 && row_offset < input_rows &&
								col_offset < input_cols) {
								expected_col_major = tensor_col_major(d, row_offset, col_offset, b);
								expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
							}
							// ColMajor
							if (result_col_major(d, r, c, patchId, b) != expected_col_major) {
								std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r
										  << " c=" << c << " d=" << d << " b=" << b << std::endl;
							}
							VERIFY_IS_EQUAL(result_col_major(d, r, c, patchId, b), expected_col_major);
							// RowMajor
							if (result_row_major(b, patchId, c, r, d) != expected_row_major) {
								std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r
										  << " c=" << c << " d=" << d << " b=" << b << std::endl;
							}
							VERIFY_IS_EQUAL(result_row_major(b, patchId, c, r, d), expected_row_major);
							// Check that ColMajor and RowMajor agree.
							VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
						}
					}
				}
			}
		}
	}
	sycl_device.deallocate(gpu_data_col_major);
	sycl_device.deallocate(gpu_data_row_major);
	sycl_device.deallocate(gpu_data_result_col_major);
	sycl_device.deallocate(gpu_data_result_row_major);
}

// Verifies VALID padding (no padding) with the same value.
template<typename DataType, typename IndexType>
static void
test_patch_padding_valid_same_value_sycl(const Eigen::SyclDevice& sycl_device)
{
	IndexType input_depth = 1;
	IndexType input_rows = 5;
	IndexType input_cols = 5;
	IndexType input_batches = 2;
	IndexType ksize = 3;  // Corresponds to the Rows and Cols for tensor.extract_image_patches<>.
	IndexType stride = 2; // Only same stride is supported.
	// ColMajor

	array<IndexType, 4> tensorColMajorRange = { { input_depth, input_rows, input_cols, input_batches } };
	array<IndexType, 4> tensorRowMajorRange = { { input_batches, input_cols, input_rows, input_depth } };
	Tensor<DataType, 4, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
	Tensor<DataType, 4, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);

	DataType* gpu_data_col_major =
		static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
	DataType* gpu_data_row_major =
		static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
	TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
	TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);
	gpu_col_major.device(sycl_device) = gpu_col_major.constant(11.0f);
	gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
	sycl_device.memcpyDeviceToHost(
		tensor_col_major.data(), gpu_data_col_major, (tensor_col_major.size()) * sizeof(DataType));
	sycl_device.memcpyDeviceToHost(
		tensor_row_major.data(), gpu_data_row_major, (tensor_row_major.size()) * sizeof(DataType));
	VERIFY_IS_EQUAL(tensor_col_major.dimension(0), tensor_row_major.dimension(3));
	VERIFY_IS_EQUAL(tensor_col_major.dimension(1), tensor_row_major.dimension(2));
	VERIFY_IS_EQUAL(tensor_col_major.dimension(2), tensor_row_major.dimension(1));
	VERIFY_IS_EQUAL(tensor_col_major.dimension(3), tensor_row_major.dimension(0));

	array<IndexType, 5> patchColMajorTensorRange = { { input_depth, ksize, ksize, 4, input_batches } };
	Tensor<DataType, 5, DataLayout, IndexType> result_col_major(patchColMajorTensorRange);
	size_t patchTensorBuffSize = result_col_major.size() * sizeof(DataType);
	DataType* gpu_data_result_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_result_col_major(gpu_data_result_col_major,
																			   patchColMajorTensorRange);
	gpu_result_col_major.device(sycl_device) =
		gpu_col_major.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
	sycl_device.memcpyDeviceToHost(result_col_major.data(), gpu_data_result_col_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(result_col_major.dimension(0), input_depth);   // depth
	VERIFY_IS_EQUAL(result_col_major.dimension(1), ksize);		   // kernel rows
	VERIFY_IS_EQUAL(result_col_major.dimension(2), ksize);		   // kernel cols
	VERIFY_IS_EQUAL(result_col_major.dimension(3), 4);			   // number of patches
	VERIFY_IS_EQUAL(result_col_major.dimension(4), input_batches); // number of batches

	// RowMajor
	array<IndexType, 5> patchRowMajorTensorRange = { { input_batches, 4, ksize, ksize, input_depth } };
	Tensor<DataType, 5, RowMajor, IndexType> result_row_major(patchRowMajorTensorRange);
	patchTensorBuffSize = result_row_major.size() * sizeof(DataType);
	DataType* gpu_data_result_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_result_row_major(gpu_data_result_row_major,
																			 patchRowMajorTensorRange);
	gpu_result_row_major.device(sycl_device) =
		gpu_row_major.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
	sycl_device.memcpyDeviceToHost(result_row_major.data(), gpu_data_result_row_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(result_col_major.dimension(0), result_row_major.dimension(4));
	VERIFY_IS_EQUAL(result_col_major.dimension(1), result_row_major.dimension(3));
	VERIFY_IS_EQUAL(result_col_major.dimension(2), result_row_major.dimension(2));
	VERIFY_IS_EQUAL(result_col_major.dimension(3), result_row_major.dimension(1));
	VERIFY_IS_EQUAL(result_col_major.dimension(4), result_row_major.dimension(0));

	// No padding is carried out.
	IndexType row_padding = 0;
	IndexType col_padding = 0;

	for (IndexType i = 0; (i + stride + ksize - 1) <= input_rows; i += stride) {	 // input rows
		for (IndexType j = 0; (j + stride + ksize - 1) <= input_cols; j += stride) { // input cols
			IndexType patchId = i + input_rows * j;
			for (IndexType r = 0; r < ksize; ++r) {						// patch rows
				for (IndexType c = 0; c < ksize; ++c) {					// patch cols
					for (IndexType d = 0; d < input_depth; ++d) {		// depth
						for (IndexType b = 0; b < input_batches; ++b) { // batch
							DataType expected_col_major = 0.0f;
							DataType expected_row_major = 0.0f;
							IndexType row_offset = r + i - row_padding;
							IndexType col_offset = c + j - col_padding;
							if (row_offset >= 0 && col_offset >= 0 && row_offset < input_rows &&
								col_offset < input_cols) {
								expected_col_major = tensor_col_major(d, row_offset, col_offset, b);
								expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
							}
							// ColMajor
							if (result_col_major(d, r, c, patchId, b) != expected_col_major) {
								std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r
										  << " c=" << c << " d=" << d << " b=" << b << std::endl;
							}
							VERIFY_IS_EQUAL(result_col_major(d, r, c, patchId, b), expected_col_major);
							// RowMajor
							if (result_row_major(b, patchId, c, r, d) != expected_row_major) {
								std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r
										  << " c=" << c << " d=" << d << " b=" << b << std::endl;
							}
							VERIFY_IS_EQUAL(result_row_major(b, patchId, c, r, d), expected_row_major);
							// Check that ColMajor and RowMajor agree.
							VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
						}
					}
				}
			}
		}
	}
}

// Verifies SAME padding.
template<typename DataType, typename IndexType>
static void
test_patch_padding_same_sycl(const Eigen::SyclDevice& sycl_device)
{
	IndexType input_depth = 3;
	IndexType input_rows = 4;
	IndexType input_cols = 2;
	IndexType input_batches = 1;
	IndexType ksize = 2;  // Corresponds to the Rows and Cols for tensor.extract_image_patches<>.
	IndexType stride = 2; // Only same stride is supported.

	// ColMajor
	array<IndexType, 4> tensorColMajorRange = { { input_depth, input_rows, input_cols, input_batches } };
	array<IndexType, 4> tensorRowMajorRange = { { input_batches, input_cols, input_rows, input_depth } };
	Tensor<DataType, 4, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
	Tensor<DataType, 4, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);

	DataType* gpu_data_col_major =
		static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
	DataType* gpu_data_row_major =
		static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
	TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
	TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);

	sycl_device.memcpyHostToDevice(
		gpu_data_col_major, tensor_col_major.data(), (tensor_col_major.size()) * sizeof(DataType));
	gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
	sycl_device.memcpyDeviceToHost(
		tensor_row_major.data(), gpu_data_row_major, (tensor_col_major.size()) * sizeof(DataType));

	VERIFY_IS_EQUAL(tensor_col_major.dimension(0), tensor_row_major.dimension(3));
	VERIFY_IS_EQUAL(tensor_col_major.dimension(1), tensor_row_major.dimension(2));
	VERIFY_IS_EQUAL(tensor_col_major.dimension(2), tensor_row_major.dimension(1));
	VERIFY_IS_EQUAL(tensor_col_major.dimension(3), tensor_row_major.dimension(0));

	// Initializes tensor with incrementing numbers.
	for (IndexType i = 0; i < tensor_col_major.size(); ++i) {
		tensor_col_major.data()[i] = i + 1;
	}

	array<IndexType, 5> patchColMajorTensorRange = { { input_depth, ksize, ksize, 2, input_batches } };
	Tensor<DataType, 5, DataLayout, IndexType> result_col_major(patchColMajorTensorRange);
	size_t patchTensorBuffSize = result_col_major.size() * sizeof(DataType);
	DataType* gpu_data_result_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_result_col_major(gpu_data_result_col_major,
																			   patchColMajorTensorRange);
	gpu_result_col_major.device(sycl_device) =
		gpu_col_major.extract_image_patches(ksize, ksize, stride, stride, PADDING_SAME);
	sycl_device.memcpyDeviceToHost(result_col_major.data(), gpu_data_result_col_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(result_col_major.dimension(0), input_depth);   // depth
	VERIFY_IS_EQUAL(result_col_major.dimension(1), ksize);		   // kernel rows
	VERIFY_IS_EQUAL(result_col_major.dimension(2), ksize);		   // kernel cols
	VERIFY_IS_EQUAL(result_col_major.dimension(3), 2);			   // number of patches
	VERIFY_IS_EQUAL(result_col_major.dimension(4), input_batches); // number of batches

	// RowMajor

	array<IndexType, 5> patchRowMajorTensorRange = { { input_batches, 2, ksize, ksize, input_depth } };
	Tensor<DataType, 5, RowMajor, IndexType> result_row_major(patchRowMajorTensorRange);
	patchTensorBuffSize = result_row_major.size() * sizeof(DataType);
	DataType* gpu_data_result_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_result_row_major(gpu_data_result_row_major,
																			 patchRowMajorTensorRange);
	gpu_result_row_major.device(sycl_device) =
		gpu_row_major.extract_image_patches(ksize, ksize, stride, stride, PADDING_SAME);
	sycl_device.memcpyDeviceToHost(result_row_major.data(), gpu_data_result_row_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(result_col_major.dimension(0), result_row_major.dimension(4));
	VERIFY_IS_EQUAL(result_col_major.dimension(1), result_row_major.dimension(3));
	VERIFY_IS_EQUAL(result_col_major.dimension(2), result_row_major.dimension(2));
	VERIFY_IS_EQUAL(result_col_major.dimension(3), result_row_major.dimension(1));
	VERIFY_IS_EQUAL(result_col_major.dimension(4), result_row_major.dimension(0));

	// Based on the calculation described in TensorTraits.h, padding happens to be 0.
	IndexType row_padding = 0;
	IndexType col_padding = 0;

	for (IndexType i = 0; (i + stride + ksize - 1) <= input_rows; i += stride) {	 // input rows
		for (IndexType j = 0; (j + stride + ksize - 1) <= input_cols; j += stride) { // input cols
			IndexType patchId = i + input_rows * j;
			for (IndexType r = 0; r < ksize; ++r) {						// patch rows
				for (IndexType c = 0; c < ksize; ++c) {					// patch cols
					for (IndexType d = 0; d < input_depth; ++d) {		// depth
						for (IndexType b = 0; b < input_batches; ++b) { // batch
							DataType expected_col_major = 0.0f;
							DataType expected_row_major = 0.0f;
							IndexType row_offset = r * stride + i - row_padding;
							IndexType col_offset = c * stride + j - col_padding;
							if (row_offset >= 0 && col_offset >= 0 && row_offset < input_rows &&
								col_offset < input_cols) {
								expected_col_major = tensor_col_major(d, row_offset, col_offset, b);
								expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
							}
							// ColMajor
							if (result_col_major(d, r, c, patchId, b) != expected_col_major) {
								std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r
										  << " c=" << c << " d=" << d << " b=" << b << std::endl;
							}
							VERIFY_IS_EQUAL(result_col_major(d, r, c, patchId, b), expected_col_major);
							// RowMajor
							if (result_row_major(b, patchId, c, r, d) != expected_row_major) {
								std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r
										  << " c=" << c << " d=" << d << " b=" << b << std::endl;
							}
							VERIFY_IS_EQUAL(result_row_major(b, patchId, c, r, d), expected_row_major);
							// Check that ColMajor and RowMajor agree.
							VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
						}
					}
				}
			}
		}
	}
}

template<typename DataType, typename IndexType>
static void
test_patch_no_extra_dim_sycl(const Eigen::SyclDevice& sycl_device)
{

	IndexType sizeDim1 = 2;
	IndexType sizeDim2 = 3;
	IndexType sizeDim3 = 5;

	// ColMajor
	array<IndexType, 3> tensorColMajorRange = { { sizeDim1, sizeDim2, sizeDim3 } };
	array<IndexType, 3> tensorRowMajorRange = { { sizeDim3, sizeDim2, sizeDim1 } };
	Tensor<DataType, 3, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
	tensor_col_major.setRandom();
	Tensor<DataType, 3, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);

	DataType* gpu_data_col_major =
		static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
	DataType* gpu_data_row_major =
		static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
	TensorMap<Tensor<DataType, 3, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
	TensorMap<Tensor<DataType, 3, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);

	sycl_device.memcpyHostToDevice(
		gpu_data_col_major, tensor_col_major.data(), (tensor_col_major.size()) * sizeof(DataType));
	gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
	sycl_device.memcpyDeviceToHost(
		tensor_row_major.data(), gpu_data_row_major, (tensor_row_major.size()) * sizeof(DataType));

	VERIFY_IS_EQUAL(tensor_col_major.dimension(0), tensor_row_major.dimension(2));
	VERIFY_IS_EQUAL(tensor_col_major.dimension(1), tensor_row_major.dimension(1));
	VERIFY_IS_EQUAL(tensor_col_major.dimension(2), tensor_row_major.dimension(0));

	// Single pixel patch: ColMajor
	array<IndexType, 4> patchColMajorTensorRange = { { sizeDim1, 1, 1, sizeDim2 * sizeDim3 } };
	Tensor<DataType, 4, DataLayout, IndexType> single_patch_col_major(patchColMajorTensorRange);
	size_t patchTensorBuffSize = single_patch_col_major.size() * sizeof(DataType);
	DataType* gpu_data_single_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_single_patch_col_major(gpu_data_single_patch_col_major,
																					 patchColMajorTensorRange);
	gpu_single_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(1, 1);
	sycl_device.memcpyDeviceToHost(single_patch_col_major.data(), gpu_data_single_patch_col_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(single_patch_col_major.dimension(0), sizeDim1);
	VERIFY_IS_EQUAL(single_patch_col_major.dimension(1), 1);
	VERIFY_IS_EQUAL(single_patch_col_major.dimension(2), 1);
	VERIFY_IS_EQUAL(single_patch_col_major.dimension(3), sizeDim2 * sizeDim3);

	// Single pixel patch: RowMajor
	array<IndexType, 4> patchRowMajorTensorRange = { { sizeDim2 * sizeDim3, 1, 1, sizeDim1 } };
	Tensor<DataType, 4, RowMajor, IndexType> single_patch_row_major(patchRowMajorTensorRange);
	patchTensorBuffSize = single_patch_row_major.size() * sizeof(DataType);
	DataType* gpu_data_single_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_single_patch_row_major(gpu_data_single_patch_row_major,
																				   patchRowMajorTensorRange);
	gpu_single_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(1, 1);
	sycl_device.memcpyDeviceToHost(single_patch_row_major.data(), gpu_data_single_patch_row_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(single_patch_row_major.dimension(0), sizeDim2 * sizeDim3);
	VERIFY_IS_EQUAL(single_patch_row_major.dimension(1), 1);
	VERIFY_IS_EQUAL(single_patch_row_major.dimension(2), 1);
	VERIFY_IS_EQUAL(single_patch_row_major.dimension(3), sizeDim1);

	for (IndexType i = 0; i < tensor_col_major.size(); ++i) {
		// ColMajor
		if (tensor_col_major.data()[i] != single_patch_col_major.data()[i]) {
			std::cout << "Mismatch detected at index " << i << " : " << tensor_col_major.data()[i] << " vs "
					  << single_patch_col_major.data()[i] << std::endl;
		}
		VERIFY_IS_EQUAL(single_patch_col_major.data()[i], tensor_col_major.data()[i]);
		// RowMajor
		if (tensor_row_major.data()[i] != single_patch_row_major.data()[i]) {
			std::cout << "Mismatch detected at index " << i << " : " << tensor_col_major.data()[i] << " vs "
					  << single_patch_row_major.data()[i] << std::endl;
		}
		VERIFY_IS_EQUAL(single_patch_row_major.data()[i], tensor_row_major.data()[i]);
		VERIFY_IS_EQUAL(tensor_col_major.data()[i], tensor_row_major.data()[i]);
		VERIFY_IS_EQUAL(single_patch_col_major.data()[i], single_patch_row_major.data()[i]);
	}

	// Entire image patch: ColMajor
	patchColMajorTensorRange = { { sizeDim1, sizeDim2, sizeDim3, sizeDim2 * sizeDim3 } };
	Tensor<DataType, 4, DataLayout, IndexType> entire_image_patch_col_major(patchColMajorTensorRange);
	patchTensorBuffSize = entire_image_patch_col_major.size() * sizeof(DataType);
	DataType* gpu_data_entire_image_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_entire_image_patch_col_major(
		gpu_data_entire_image_patch_col_major, patchColMajorTensorRange);
	gpu_entire_image_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(3, 5);
	sycl_device.memcpyDeviceToHost(
		entire_image_patch_col_major.data(), gpu_data_entire_image_patch_col_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(0), 2);
	VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(1), 3);
	VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(2), 5);
	VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(3), 3 * 5);

	// Entire image patch: RowMajor
	patchRowMajorTensorRange = { { sizeDim2 * sizeDim3, sizeDim3, sizeDim2, sizeDim1 } };
	Tensor<DataType, 4, RowMajor, IndexType> entire_image_patch_row_major(patchRowMajorTensorRange);
	patchTensorBuffSize = entire_image_patch_row_major.size() * sizeof(DataType);
	DataType* gpu_data_entire_image_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_entire_image_patch_row_major(
		gpu_data_entire_image_patch_row_major, patchRowMajorTensorRange);
	gpu_entire_image_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(3, 5);
	sycl_device.memcpyDeviceToHost(
		entire_image_patch_row_major.data(), gpu_data_entire_image_patch_row_major, patchTensorBuffSize);
	VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(0), 3 * 5);
	VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(1), 5);
	VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(2), 3);
	VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(3), 2);

	for (IndexType i = 0; i < 3; ++i) {
		for (IndexType j = 0; j < 5; ++j) {
			IndexType patchId = i + 3 * j;
			for (IndexType r = 0; r < 3; ++r) {
				for (IndexType c = 0; c < 5; ++c) {
					for (IndexType d = 0; d < 2; ++d) {
						DataType expected_col_major = 0.0f;
						DataType expected_row_major = 0.0f;
						if (r - 1 + i >= 0 && c - 2 + j >= 0 && r - 1 + i < 3 && c - 2 + j < 5) {
							expected_col_major = tensor_col_major(d, r - 1 + i, c - 2 + j);
							expected_row_major = tensor_row_major(c - 2 + j, r - 1 + i, d);
						}
						// ColMajor
						if (entire_image_patch_col_major(d, r, c, patchId) != expected_col_major) {
							std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
									  << " d=" << d << std::endl;
						}
						VERIFY_IS_EQUAL(entire_image_patch_col_major(d, r, c, patchId), expected_col_major);
						// RowMajor
						if (entire_image_patch_row_major(patchId, c, r, d) != expected_row_major) {
							std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
									  << " d=" << d << std::endl;
						}
						VERIFY_IS_EQUAL(entire_image_patch_row_major(patchId, c, r, d), expected_row_major);
						// Check that ColMajor and RowMajor agree.
						VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
					}
				}
			}
		}
	}

	// 2D patch: ColMajor
	patchColMajorTensorRange = { { sizeDim1, 2, 2, sizeDim2 * sizeDim3 } };
	Tensor<DataType, 4, DataLayout, IndexType> twod_patch_col_major(patchColMajorTensorRange);
	patchTensorBuffSize = twod_patch_col_major.size() * sizeof(DataType);
	DataType* gpu_data_twod_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_twod_patch_col_major(gpu_data_twod_patch_col_major,
																				   patchColMajorTensorRange);
	gpu_twod_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(2, 2);
	sycl_device.memcpyDeviceToHost(twod_patch_col_major.data(), gpu_data_twod_patch_col_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(twod_patch_col_major.dimension(0), 2);
	VERIFY_IS_EQUAL(twod_patch_col_major.dimension(1), 2);
	VERIFY_IS_EQUAL(twod_patch_col_major.dimension(2), 2);
	VERIFY_IS_EQUAL(twod_patch_col_major.dimension(3), 3 * 5);

	// 2D patch: RowMajor
	patchRowMajorTensorRange = { { sizeDim2 * sizeDim3, 2, 2, sizeDim1 } };
	Tensor<DataType, 4, RowMajor, IndexType> twod_patch_row_major(patchRowMajorTensorRange);
	patchTensorBuffSize = twod_patch_row_major.size() * sizeof(DataType);
	DataType* gpu_data_twod_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_twod_patch_row_major(gpu_data_twod_patch_row_major,
																				 patchRowMajorTensorRange);
	gpu_twod_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(2, 2);
	sycl_device.memcpyDeviceToHost(twod_patch_row_major.data(), gpu_data_twod_patch_row_major, patchTensorBuffSize);
	VERIFY_IS_EQUAL(twod_patch_row_major.dimension(0), 3 * 5);
	VERIFY_IS_EQUAL(twod_patch_row_major.dimension(1), 2);
	VERIFY_IS_EQUAL(twod_patch_row_major.dimension(2), 2);
	VERIFY_IS_EQUAL(twod_patch_row_major.dimension(3), 2);

	// Based on the calculation described in TensorTraits.h, padding happens to be 0.
	IndexType row_padding = 0;
	IndexType col_padding = 0;
	IndexType stride = 1;

	for (IndexType i = 0; i < 3; ++i) {
		for (IndexType j = 0; j < 5; ++j) {
			IndexType patchId = i + 3 * j;
			for (IndexType r = 0; r < 2; ++r) {
				for (IndexType c = 0; c < 2; ++c) {
					for (IndexType d = 0; d < 2; ++d) {
						DataType expected_col_major = 0.0f;
						DataType expected_row_major = 0.0f;
						IndexType row_offset = r * stride + i - row_padding;
						IndexType col_offset = c * stride + j - col_padding;
						// ColMajor
						if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor_col_major.dimension(1) &&
							col_offset < tensor_col_major.dimension(2)) {
							expected_col_major = tensor_col_major(d, row_offset, col_offset);
						}
						if (twod_patch_col_major(d, r, c, patchId) != expected_col_major) {
							std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
									  << " d=" << d << std::endl;
						}
						VERIFY_IS_EQUAL(twod_patch_col_major(d, r, c, patchId), expected_col_major);
						// RowMajor
						if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor_row_major.dimension(1) &&
							col_offset < tensor_row_major.dimension(0)) {
							expected_row_major = tensor_row_major(col_offset, row_offset, d);
						}
						if (twod_patch_row_major(patchId, c, r, d) != expected_row_major) {
							std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
									  << " d=" << d << std::endl;
						}
						VERIFY_IS_EQUAL(twod_patch_row_major(patchId, c, r, d), expected_row_major);
						// Check that ColMajor and RowMajor agree.
						VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
					}
				}
			}
		}
	}

	sycl_device.deallocate(gpu_data_col_major);
	sycl_device.deallocate(gpu_data_row_major);
	sycl_device.deallocate(gpu_data_single_patch_col_major);
	sycl_device.deallocate(gpu_data_single_patch_row_major);
	sycl_device.deallocate(gpu_data_entire_image_patch_col_major);
	sycl_device.deallocate(gpu_data_entire_image_patch_row_major);
	sycl_device.deallocate(gpu_data_twod_patch_col_major);
	sycl_device.deallocate(gpu_data_twod_patch_row_major);
}

template<typename DataType, typename IndexType>
static void
test_imagenet_patches_sycl(const Eigen::SyclDevice& sycl_device)
{
	// Test the code on typical configurations used by the 'imagenet' benchmarks at
	// https://github.com/soumith/convnet-benchmarks
	// ColMajor
	IndexType sizeDim1 = 3;
	IndexType sizeDim2 = 128;
	IndexType sizeDim3 = 128;
	IndexType sizeDim4 = 16;
	array<IndexType, 4> tensorColMajorRange = { { sizeDim1, sizeDim2, sizeDim3, sizeDim4 } };
	Tensor<DataType, 4, DataLayout, IndexType> l_in_col_major(tensorColMajorRange);
	l_in_col_major.setRandom();

	DataType* gpu_data_l_in_col_major =
		static_cast<DataType*>(sycl_device.allocate(l_in_col_major.size() * sizeof(DataType)));
	TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_l_in_col_major(gpu_data_l_in_col_major,
																		   tensorColMajorRange);

	sycl_device.memcpyHostToDevice(
		gpu_data_l_in_col_major, l_in_col_major.data(), (l_in_col_major.size()) * sizeof(DataType));

	array<IndexType, 5> patchTensorRange = { { sizeDim1, 11, 11, sizeDim2 * sizeDim3, sizeDim4 } };
	Tensor<DataType, 5, DataLayout, IndexType> l_out_col_major(patchTensorRange);
	size_t patchTensorBuffSize = l_out_col_major.size() * sizeof(DataType);
	DataType* gpu_data_l_out_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_l_out_col_major(gpu_data_l_out_col_major,
																			  patchTensorRange);
	gpu_l_out_col_major.device(sycl_device) = gpu_l_in_col_major.extract_image_patches(11, 11);
	sycl_device.memcpyDeviceToHost(l_out_col_major.data(), gpu_data_l_out_col_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(l_out_col_major.dimension(0), sizeDim1);
	VERIFY_IS_EQUAL(l_out_col_major.dimension(1), 11);
	VERIFY_IS_EQUAL(l_out_col_major.dimension(2), 11);
	VERIFY_IS_EQUAL(l_out_col_major.dimension(3), sizeDim2 * sizeDim3);
	VERIFY_IS_EQUAL(l_out_col_major.dimension(4), sizeDim4);

	// RowMajor
	patchTensorRange = { { sizeDim4, sizeDim2 * sizeDim3, 11, 11, sizeDim1 } };
	Tensor<DataType, 5, RowMajor, IndexType> l_out_row_major(patchTensorRange);
	patchTensorBuffSize = l_out_row_major.size() * sizeof(DataType);
	DataType* gpu_data_l_out_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_l_out_row_major(gpu_data_l_out_row_major, patchTensorRange);
	gpu_l_out_row_major.device(sycl_device) = gpu_l_in_col_major.swap_layout().extract_image_patches(11, 11);
	sycl_device.memcpyDeviceToHost(l_out_row_major.data(), gpu_data_l_out_row_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(l_out_row_major.dimension(0), sizeDim4);
	VERIFY_IS_EQUAL(l_out_row_major.dimension(1), sizeDim2 * sizeDim3);
	VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 11);
	VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 11);
	VERIFY_IS_EQUAL(l_out_row_major.dimension(4), sizeDim1);

	for (IndexType b = 0; b < 16; ++b) {
		for (IndexType i = 0; i < 128; ++i) {
			for (IndexType j = 0; j < 128; ++j) {
				IndexType patchId = i + 128 * j;
				for (IndexType c = 0; c < 11; ++c) {
					for (IndexType r = 0; r < 11; ++r) {
						for (IndexType d = 0; d < 3; ++d) {
							DataType expected = 0.0f;
							if (r - 5 + i >= 0 && c - 5 + j >= 0 && r - 5 + i < 128 && c - 5 + j < 128) {
								expected = l_in_col_major(d, r - 5 + i, c - 5 + j, b);
							}
							// ColMajor
							if (l_out_col_major(d, r, c, patchId, b) != expected) {
								std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r
										  << " c=" << c << " d=" << d << " b=" << b << std::endl;
							}
							VERIFY_IS_EQUAL(l_out_col_major(d, r, c, patchId, b), expected);
							// RowMajor
							if (l_out_row_major(b, patchId, c, r, d) != expected) {
								std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r
										  << " c=" << c << " d=" << d << " b=" << b << std::endl;
							}
							VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
						}
					}
				}
			}
		}
	}

	// ColMajor
	sycl_device.deallocate(gpu_data_l_in_col_major);
	sycl_device.deallocate(gpu_data_l_out_col_major);
	sizeDim1 = 16;
	sizeDim2 = 64;
	sizeDim3 = 64;
	sizeDim4 = 32;
	tensorColMajorRange = { { sizeDim1, sizeDim2, sizeDim3, sizeDim4 } };
	l_in_col_major.resize(tensorColMajorRange);
	l_in_col_major.setRandom();
	gpu_data_l_in_col_major = static_cast<DataType*>(sycl_device.allocate(l_in_col_major.size() * sizeof(DataType)));
	TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_l_in_col_major_resize1(gpu_data_l_in_col_major,
																				   tensorColMajorRange);

	patchTensorRange = { { sizeDim1, 9, 9, sizeDim2 * sizeDim3, sizeDim4 } };
	l_out_col_major.resize(patchTensorRange);
	patchTensorBuffSize = l_out_col_major.size() * sizeof(DataType);
	gpu_data_l_out_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_l_out_col_major_resize1(gpu_data_l_out_col_major,
																					  patchTensorRange);
	sycl_device.memcpyHostToDevice(
		gpu_data_l_in_col_major, l_in_col_major.data(), (l_in_col_major.size()) * sizeof(DataType));
	gpu_l_out_col_major_resize1.device(sycl_device) = gpu_l_in_col_major_resize1.extract_image_patches(9, 9);
	sycl_device.memcpyDeviceToHost(l_out_col_major.data(), gpu_data_l_out_col_major, patchTensorBuffSize);
	VERIFY_IS_EQUAL(l_out_col_major.dimension(0), 16);
	VERIFY_IS_EQUAL(l_out_col_major.dimension(1), 9);
	VERIFY_IS_EQUAL(l_out_col_major.dimension(2), 9);
	VERIFY_IS_EQUAL(l_out_col_major.dimension(3), 64 * 64);
	VERIFY_IS_EQUAL(l_out_col_major.dimension(4), 32);

	// RowMajor
	sycl_device.deallocate(gpu_data_l_out_row_major);
	patchTensorRange = { { sizeDim4, sizeDim2 * sizeDim3, 9, 9, sizeDim1 } };
	l_out_row_major.resize(patchTensorRange);
	patchTensorBuffSize = l_out_row_major.size() * sizeof(DataType);
	gpu_data_l_out_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_l_out_row_major_resize1(gpu_data_l_out_row_major,
																					patchTensorRange);
	gpu_l_out_row_major_resize1.device(sycl_device) =
		gpu_l_in_col_major_resize1.swap_layout().extract_image_patches(9, 9);
	sycl_device.memcpyDeviceToHost(l_out_row_major.data(), gpu_data_l_out_row_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(l_out_row_major.dimension(0), 32);
	VERIFY_IS_EQUAL(l_out_row_major.dimension(1), 64 * 64);
	VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 9);
	VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 9);
	VERIFY_IS_EQUAL(l_out_row_major.dimension(4), 16);

	for (IndexType b = 0; b < 32; ++b) {
		for (IndexType i = 0; i < 64; ++i) {
			for (IndexType j = 0; j < 64; ++j) {
				IndexType patchId = i + 64 * j;
				for (IndexType c = 0; c < 9; ++c) {
					for (IndexType r = 0; r < 9; ++r) {
						for (IndexType d = 0; d < 16; ++d) {
							DataType expected = 0.0f;
							if (r - 4 + i >= 0 && c - 4 + j >= 0 && r - 4 + i < 64 && c - 4 + j < 64) {
								expected = l_in_col_major(d, r - 4 + i, c - 4 + j, b);
							}
							// ColMajor
							if (l_out_col_major(d, r, c, patchId, b) != expected) {
								std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r
										  << " c=" << c << " d=" << d << " b=" << b << std::endl;
							}
							VERIFY_IS_EQUAL(l_out_col_major(d, r, c, patchId, b), expected);
							// RowMajor
							if (l_out_row_major(b, patchId, c, r, d) != expected) {
								std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r
										  << " c=" << c << " d=" << d << " b=" << b << std::endl;
							}
							VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
						}
					}
				}
			}
		}
	}

	// ColMajor

	sycl_device.deallocate(gpu_data_l_in_col_major);
	sycl_device.deallocate(gpu_data_l_out_col_major);
	sizeDim1 = 32;
	sizeDim2 = 16;
	sizeDim3 = 16;
	sizeDim4 = 32;
	tensorColMajorRange = { { sizeDim1, sizeDim2, sizeDim3, sizeDim4 } };
	l_in_col_major.resize(tensorColMajorRange);
	l_in_col_major.setRandom();
	gpu_data_l_in_col_major = static_cast<DataType*>(sycl_device.allocate(l_in_col_major.size() * sizeof(DataType)));
	TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_l_in_col_major_resize2(gpu_data_l_in_col_major,
																				   tensorColMajorRange);

	patchTensorRange = { { sizeDim1, 7, 7, sizeDim2 * sizeDim3, sizeDim4 } };
	l_out_col_major.resize(patchTensorRange);
	patchTensorBuffSize = l_out_col_major.size() * sizeof(DataType);
	gpu_data_l_out_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_l_out_col_major_resize2(gpu_data_l_out_col_major,
																					  patchTensorRange);
	sycl_device.memcpyHostToDevice(
		gpu_data_l_in_col_major, l_in_col_major.data(), (l_in_col_major.size()) * sizeof(DataType));
	gpu_l_out_col_major_resize2.device(sycl_device) = gpu_l_in_col_major_resize2.extract_image_patches(7, 7);
	sycl_device.memcpyDeviceToHost(l_out_col_major.data(), gpu_data_l_out_col_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(l_out_col_major.dimension(0), 32);
	VERIFY_IS_EQUAL(l_out_col_major.dimension(1), 7);
	VERIFY_IS_EQUAL(l_out_col_major.dimension(2), 7);
	VERIFY_IS_EQUAL(l_out_col_major.dimension(3), 16 * 16);
	VERIFY_IS_EQUAL(l_out_col_major.dimension(4), 32);

	// RowMajor
	sycl_device.deallocate(gpu_data_l_out_row_major);
	patchTensorRange = { { sizeDim4, sizeDim2 * sizeDim3, 7, 7, sizeDim1 } };
	l_out_row_major.resize(patchTensorRange);
	patchTensorBuffSize = l_out_row_major.size() * sizeof(DataType);
	gpu_data_l_out_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_l_out_row_major_resize2(gpu_data_l_out_row_major,
																					patchTensorRange);
	gpu_l_out_row_major_resize2.device(sycl_device) =
		gpu_l_in_col_major_resize2.swap_layout().extract_image_patches(7, 7);
	sycl_device.memcpyDeviceToHost(l_out_row_major.data(), gpu_data_l_out_row_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(l_out_row_major.dimension(0), 32);
	VERIFY_IS_EQUAL(l_out_row_major.dimension(1), 16 * 16);
	VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 7);
	VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 7);
	VERIFY_IS_EQUAL(l_out_row_major.dimension(4), 32);

	for (IndexType b = 0; b < 32; ++b) {
		for (IndexType i = 0; i < 16; ++i) {
			for (IndexType j = 0; j < 16; ++j) {
				IndexType patchId = i + 16 * j;
				for (IndexType c = 0; c < 7; ++c) {
					for (IndexType r = 0; r < 7; ++r) {
						for (IndexType d = 0; d < 32; ++d) {
							DataType expected = 0.0f;
							if (r - 3 + i >= 0 && c - 3 + j >= 0 && r - 3 + i < 16 && c - 3 + j < 16) {
								expected = l_in_col_major(d, r - 3 + i, c - 3 + j, b);
							}
							// ColMajor
							if (l_out_col_major(d, r, c, patchId, b) != expected) {
								std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r
										  << " c=" << c << " d=" << d << " b=" << b << std::endl;
							}
							VERIFY_IS_EQUAL(l_out_col_major(d, r, c, patchId, b), expected);
							// RowMajor
							if (l_out_row_major(b, patchId, c, r, d) != expected) {
								std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r
										  << " c=" << c << " d=" << d << " b=" << b << std::endl;
							}
							VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
						}
					}
				}
			}
		}
	}

	// ColMajor
	sycl_device.deallocate(gpu_data_l_in_col_major);
	sycl_device.deallocate(gpu_data_l_out_col_major);
	sizeDim1 = 64;
	sizeDim2 = 13;
	sizeDim3 = 13;
	sizeDim4 = 32;
	tensorColMajorRange = { { sizeDim1, sizeDim2, sizeDim3, sizeDim4 } };
	l_in_col_major.resize(tensorColMajorRange);
	l_in_col_major.setRandom();
	gpu_data_l_in_col_major = static_cast<DataType*>(sycl_device.allocate(l_in_col_major.size() * sizeof(DataType)));
	TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_l_in_col_major_resize3(gpu_data_l_in_col_major,
																				   tensorColMajorRange);

	patchTensorRange = { { sizeDim1, 3, 3, sizeDim2 * sizeDim3, sizeDim4 } };
	l_out_col_major.resize(patchTensorRange);
	patchTensorBuffSize = l_out_col_major.size() * sizeof(DataType);
	gpu_data_l_out_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_l_out_col_major_resize3(gpu_data_l_out_col_major,
																					  patchTensorRange);
	sycl_device.memcpyHostToDevice(
		gpu_data_l_in_col_major, l_in_col_major.data(), (l_in_col_major.size()) * sizeof(DataType));
	gpu_l_out_col_major_resize3.device(sycl_device) = gpu_l_in_col_major_resize3.extract_image_patches(3, 3);
	sycl_device.memcpyDeviceToHost(l_out_col_major.data(), gpu_data_l_out_col_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(l_out_col_major.dimension(0), 64);
	VERIFY_IS_EQUAL(l_out_col_major.dimension(1), 3);
	VERIFY_IS_EQUAL(l_out_col_major.dimension(2), 3);
	VERIFY_IS_EQUAL(l_out_col_major.dimension(3), 13 * 13);
	VERIFY_IS_EQUAL(l_out_col_major.dimension(4), 32);

	// RowMajor
	sycl_device.deallocate(gpu_data_l_out_row_major);
	patchTensorRange = { { sizeDim4, sizeDim2 * sizeDim3, 3, 3, sizeDim1 } };
	l_out_row_major.resize(patchTensorRange);
	patchTensorBuffSize = l_out_row_major.size() * sizeof(DataType);
	gpu_data_l_out_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
	TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_l_out_row_major_resize3(gpu_data_l_out_row_major,
																					patchTensorRange);
	gpu_l_out_row_major_resize3.device(sycl_device) =
		gpu_l_in_col_major_resize3.swap_layout().extract_image_patches(3, 3);
	sycl_device.memcpyDeviceToHost(l_out_row_major.data(), gpu_data_l_out_row_major, patchTensorBuffSize);

	VERIFY_IS_EQUAL(l_out_row_major.dimension(0), 32);
	VERIFY_IS_EQUAL(l_out_row_major.dimension(1), 13 * 13);
	VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 3);
	VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 3);
	VERIFY_IS_EQUAL(l_out_row_major.dimension(4), 64);

	for (IndexType b = 0; b < 32; ++b) {
		for (IndexType i = 0; i < 13; ++i) {
			for (IndexType j = 0; j < 13; ++j) {
				IndexType patchId = i + 13 * j;
				for (IndexType c = 0; c < 3; ++c) {
					for (IndexType r = 0; r < 3; ++r) {
						for (IndexType d = 0; d < 64; ++d) {
							DataType expected = 0.0f;
							if (r - 1 + i >= 0 && c - 1 + j >= 0 && r - 1 + i < 13 && c - 1 + j < 13) {
								expected = l_in_col_major(d, r - 1 + i, c - 1 + j, b);
							}
							// ColMajor
							if (l_out_col_major(d, r, c, patchId, b) != expected) {
								std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r
										  << " c=" << c << " d=" << d << " b=" << b << std::endl;
							}
							VERIFY_IS_EQUAL(l_out_col_major(d, r, c, patchId, b), expected);
							// RowMajor
							if (l_out_row_major(b, patchId, c, r, d) != expected) {
								std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r
										  << " c=" << c << " d=" << d << " b=" << b << std::endl;
							}
							VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
						}
					}
				}
			}
		}
	}
	sycl_device.deallocate(gpu_data_l_in_col_major);
	sycl_device.deallocate(gpu_data_l_out_col_major);
	sycl_device.deallocate(gpu_data_l_out_row_major);
}

template<typename DataType, typename dev_Selector>
void
sycl_tensor_image_patch_test_per_device(dev_Selector s)
{
	QueueInterface queueInterface(s);
	auto sycl_device = Eigen::SyclDevice(&queueInterface);
	test_simple_image_patch_sycl<DataType, int64_t>(sycl_device);
	test_patch_padding_valid_sycl<DataType, int64_t>(sycl_device);
	test_patch_padding_valid_same_value_sycl<DataType, int64_t>(sycl_device);
	test_patch_padding_same_sycl<DataType, int64_t>(sycl_device);
	test_patch_no_extra_dim_sycl<DataType, int64_t>(sycl_device);
	test_imagenet_patches_sycl<DataType, int64_t>(sycl_device);
}
EIGEN_DECLARE_TEST(cxx11_tensor_image_patch_sycl)
{
	for (const auto& device : Eigen::get_sycl_supported_devices()) {
		CALL_SUBTEST(sycl_tensor_image_patch_test_per_device<float>(device));
	}
}
